package com.ruoyi.system.service.impl;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.pinyin4j.PinyinUtil;
import com.ruoyi.system.domain.TalentTemplate;
import com.ruoyi.system.domain.TalentTemplateField;
import com.ruoyi.system.mapper.TalentTemplateMapper;
import com.ruoyi.system.mapper.TalentTemplateFieldMapper;
import com.ruoyi.system.service.ITalentTemplateService;

/**
 * 人才库模板配置 服务层处理
 * 
 * @author ruoyi
 */
@Service
public class TalentTemplateServiceImpl implements ITalentTemplateService
{
    @Autowired
    private TalentTemplateMapper talentTemplateMapper;

    @Autowired
    private TalentTemplateFieldMapper talentTemplateFieldMapper;

    /**
     * 查询人才库模板配置列表
     * 
     * @param talentTemplate 人才库模板配置
     * @return 人才库模板配置集合
     */
    @Override
    public List<TalentTemplate> selectTalentTemplateList(TalentTemplate talentTemplate)
    {
        return talentTemplateMapper.selectTalentTemplateList(talentTemplate);
    }

    /**
     * 通过ID查询人才库模板配置
     * 
     * @param id 主键ID
     * @return 人才库模板配置对象
     */
    @Override
    public TalentTemplate selectTalentTemplateById(Long id)
    {
        return talentTemplateMapper.selectTalentTemplateById(id);
    }

    /**
     * 通过岗位ID查询人才库模板配置
     * 
     * @param postId 岗位ID
     * @return 人才库模板配置对象
     */
    @Override
    public TalentTemplate selectTalentTemplateByPostId(Long postId)
    {
        return talentTemplateMapper.selectTalentTemplateByPostId(postId);
    }

    /**
     * 新增人才库模板配置（同时创建动态表）
     * 
     * @param talentTemplate 人才库模板配置
     * @return 结果
     */
    @Override
    @Transactional
    public int insertTalentTemplate(TalentTemplate talentTemplate)
    {
        // 检查岗位是否已创建模板
        TalentTemplate exist = talentTemplateMapper.selectTalentTemplateByPostId(talentTemplate.getPostId());
        if (StringUtils.isNotNull(exist))
        {
            throw new ServiceException("该岗位已创建人才库模板");
        }

        // 生成表名：t_template_{岗位名称的拼音}
        String tableName = "t_template_" + convertToPinyin(talentTemplate.getPostName());
        talentTemplate.setTableName(tableName);

        // 创建动态表
        talentTemplateMapper.createDynamicTable(tableName, talentTemplate.getPostName());

        // 插入模板配置
        return talentTemplateMapper.insertTalentTemplate(talentTemplate);
    }

    /**
     * 修改人才库模板配置
     * 
     * @param talentTemplate 人才库模板配置
     * @return 结果
     */
    @Override
    public int updateTalentTemplate(TalentTemplate talentTemplate)
    {
        return talentTemplateMapper.updateTalentTemplate(talentTemplate);
    }

    /**
     * 删除人才库模板配置（同时删除动态表）
     * 
     * @param id 主键ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTalentTemplateById(Long id)
    {
        TalentTemplate template = talentTemplateMapper.selectTalentTemplateById(id);
        if (StringUtils.isNull(template))
        {
            throw new ServiceException("模板不存在");
        }

        // 删除动态表
        talentTemplateMapper.dropDynamicTable(template.getTableName());

        // 删除字段配置
        talentTemplateFieldMapper.deleteTalentTemplateFieldByTemplateId(id);

        // 删除模板配置
        return talentTemplateMapper.deleteTalentTemplateById(id);
    }

    /**
     * 批量删除人才库模板配置
     * 
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTalentTemplateByIds(Long[] ids)
    {
        int count = 0;
        for (Long id : ids)
        {
            count += deleteTalentTemplateById(id);
        }
        return count;
    }

    /**
     * 保存模板字段（从SpreadJS传入的字段列表）
     * 
     * @param templateId 模板ID
     * @param fields 字段列表
     * @return 结果
     */
    @Override
    @Transactional
    public int saveTemplateFields(Long templateId, List<TalentTemplateField> fields)
    {
        TalentTemplate template = talentTemplateMapper.selectTalentTemplateById(templateId);
        if (StringUtils.isNull(template))
        {
            throw new ServiceException("模板不存在");
        }

        // 获取现有字段
        List<TalentTemplateField> existFields = talentTemplateFieldMapper.selectFieldsByTemplateId(templateId);
        Map<String, TalentTemplateField> existFieldMap = new HashMap<>();
        for (TalentTemplateField field : existFields)
        {
            existFieldMap.put(field.getFieldName(), field);
        }

        // 处理新增和更新的字段
        for (TalentTemplateField field : fields)
        {
            field.setTemplateId(templateId);
            field.setTableName(template.getTableName());

            if (existFieldMap.containsKey(field.getFieldName()))
            {
                // 更新字段
                field.setId(existFieldMap.get(field.getFieldName()).getId());
                talentTemplateFieldMapper.updateTalentTemplateField(field);
                existFieldMap.remove(field.getFieldName());
            }
            else
            {
                // 新增字段
                talentTemplateFieldMapper.insertTalentTemplateField(field);
                // 在动态表中添加字段
                talentTemplateMapper.addDynamicColumn(template.getTableName(), 
                    field.getFieldName(), 
                    field.getFieldType(), 
                    field.getFieldLength(), 
                    field.getFieldLabel());
            }
        }

        // 删除不存在的字段
        for (TalentTemplateField field : existFieldMap.values())
        {
            // 检查字段是否有数据
            int count = talentTemplateMapper.checkColumnHasData(template.getTableName(), field.getFieldName());
            if (count > 0)
            {
                throw new ServiceException("字段【" + field.getFieldLabel() + "】存在数据，不能删除");
            }
            // 删除动态表字段
            talentTemplateMapper.dropDynamicColumn(template.getTableName(), field.getFieldName());
            // 删除字段配置
            talentTemplateFieldMapper.deleteTalentTemplateFieldById(field.getId());
        }

        return fields.size();
    }

    /**
     * 批量保存字段列表（中文转拼音）
     * 
     * @param templateId 模板ID
     * @param fields 字段列表（fieldLabel为中文）
     * @return 结果
     */
    @Override
    @Transactional
    public int saveFieldListBatch(Long templateId, List<TalentTemplateField> fields)
    {
        TalentTemplate template = talentTemplateMapper.selectTalentTemplateById(templateId);
        if (StringUtils.isNull(template))
        {
            throw new ServiceException("模板不存在");
        }

        // 获取现有字段，建立ID映射
        List<TalentTemplateField> existFields = talentTemplateFieldMapper.selectFieldsByTemplateId(templateId);
        Map<Long, TalentTemplateField> existFieldIdMap = new HashMap<>();
        Map<String, TalentTemplateField> existFieldLabelMap = new HashMap<>();
        for (TalentTemplateField field : existFields)
        {
            existFieldIdMap.put(field.getId(), field);
            existFieldLabelMap.put(field.getFieldLabel(), field);
        }

        Set<Long> processedFieldIds = new HashSet<>();

        // 处理字段变更
        for (TalentTemplateField field : fields)
        {
            field.setTemplateId(templateId);
            field.setTableName(template.getTableName());
            field.setFieldType("varchar");
            field.setFieldLength(1200);

            TalentTemplateField originalField = field.getOriginalField();
            
            if (originalField != null && originalField.getId() != null)
            {
                // 有原始字段ID，这是一个现有字段的修改
                TalentTemplateField existField = existFieldIdMap.get(originalField.getId());
                if (existField != null)
                {
                    processedFieldIds.add(existField.getId());
                    
                    // 检查是否是字段重命名
                    if (!existField.getFieldLabel().equals(field.getFieldLabel()))
                    {
                        System.out.println("检测到字段重命名: " + existField.getFieldLabel() + " -> " + field.getFieldLabel());
                        
                        // 生成新的字段名，确保唯一性
                        String newFieldName = generateUniqueFieldName(field.getFieldLabel(), template.getTableName(), existFields);
                        
                        // 重命名数据库列
                        try {
                            talentTemplateMapper.renameColumn(template.getTableName(), existField.getFieldName(), newFieldName);
                            System.out.println("成功重命名数据库列: " + existField.getFieldName() + " -> " + newFieldName);
                        } catch (Exception e) {
                            System.err.println("重命名数据库列失败: " + e.getMessage());
                            throw new ServiceException("重命名字段【" + existField.getFieldLabel() + "】失败: " + e.getMessage());
                        }
                        
                        // 更新字段信息
                        field.setFieldName(newFieldName);
                    }
                    else
                    {
                        // 保持原有列名
                        field.setFieldName(existField.getFieldName());
                    }
                    
                    // 更新字段配置
                    field.setId(existField.getId());
                    talentTemplateFieldMapper.updateTalentTemplateField(field);
                }
                else
                {
                    throw new ServiceException("原始字段不存在，ID: " + originalField.getId());
                }
            }
            else
            {
                // 检查是否存在同名字段（按fieldLabel匹配）
                TalentTemplateField existField = existFieldLabelMap.get(field.getFieldLabel());
                if (existField != null)
                {
                    // 更新现有字段
                    processedFieldIds.add(existField.getId());
                    field.setId(existField.getId());
                    field.setFieldName(existField.getFieldName()); // 保持原有列名
                    talentTemplateFieldMapper.updateTalentTemplateField(field);
                }
                else
                {
                    // 新增字段
                    String fieldName = generateUniqueFieldName(field.getFieldLabel(), template.getTableName(), existFields);
                    field.setFieldName(fieldName);
                    
                    talentTemplateFieldMapper.insertTalentTemplateField(field);
                    // 在动态表中添加字段
                    talentTemplateMapper.addDynamicColumn(template.getTableName(), 
                        field.getFieldName(), 
                        field.getFieldType(), 
                        field.getFieldLength(), 
                        field.getFieldLabel());
                }
            }
        }

        // 删除未处理的字段（被删除的字段）
        for (TalentTemplateField field : existFields)
        {
            if (!processedFieldIds.contains(field.getId()))
            {
                // 检查字段是否有数据
                int count = talentTemplateMapper.checkColumnHasData(template.getTableName(), field.getFieldName());
                if (count > 0)
                {
                    throw new ServiceException("字段【" + field.getFieldLabel() + "】存在数据，不能删除");
                }
                // 删除动态表字段
                talentTemplateMapper.dropDynamicColumn(template.getTableName(), field.getFieldName());
                // 删除字段配置
                talentTemplateFieldMapper.deleteTalentTemplateFieldById(field.getId());
            }
        }

        return fields.size();
    }

    /**
     * 查询模板字段列表
     * 
     * @param templateId 模板ID
     * @return 字段列表
     */
    @Override
    public List<TalentTemplateField> selectFieldsByTemplateId(Long templateId)
    {
        return talentTemplateFieldMapper.selectFieldsByTemplateId(templateId);
    }

    /**
     * 删除模板字段
     * 
     * @param templateId 模板ID
     * @param fieldId 字段ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTemplateField(Long templateId, Long fieldId)
    {
        TalentTemplate template = talentTemplateMapper.selectTalentTemplateById(templateId);
        TalentTemplateField field = talentTemplateFieldMapper.selectTalentTemplateFieldById(fieldId);

        if (StringUtils.isNull(template) || StringUtils.isNull(field))
        {
            throw new ServiceException("模板或字段不存在");
        }

        // 检查字段是否有数据
        int count = talentTemplateMapper.checkColumnHasData(template.getTableName(), field.getFieldName());
        if (count > 0)
        {
            throw new ServiceException("字段【" + field.getFieldLabel() + "】存在数据，不能删除");
        }

        // 删除动态表字段
        talentTemplateMapper.dropDynamicColumn(template.getTableName(), field.getFieldName());

        // 删除字段配置
        return talentTemplateFieldMapper.deleteTalentTemplateFieldById(fieldId);
    }

    /**
     * 查询动态表数据
     * 
     * @param tableName 表名
     * @return 数据列表
     */
    @Override
    public List<Map<String, Object>> selectDynamicTableData(String tableName)
    {
        return talentTemplateMapper.selectDynamicTableData(tableName);
    }

    /**
     * 保存动态表数据（批量保存SpreadJS数据）
     * 
     * @param tableName 表名
     * @param dataList 数据列表
     * @return 结果
     */
    @Override
    @Transactional
    public int saveDynamicTableData(String tableName, List<Map<String, Object>> dataList)
    {
        // 此方法需要使用动态SQL，在Mapper中实现
        // 这里简化处理，实际使用时需要根据具体需求优化
        int count = 0;
        for (Map<String, Object> data : dataList)
        {
            if (data.containsKey("id") && data.get("id") != null)
            {
                // 更新
                // 设置更新时间
                data.put("update_time", new java.util.Date());
                count += talentTemplateMapper.updateDynamicTableData(tableName, data, Long.parseLong(data.get("id").toString()));
            }
            else
            {
                // 新增
                // 设置创建时间与更新时间
                java.util.Date now = new java.util.Date();
                data.putIfAbsent("create_time", now);
                data.put("update_time", now);
                count += talentTemplateMapper.insertDynamicTableData(tableName, data);
            }
        }
        return count;
    }

    /**
     * 将中文转换为拼音
     * 
     * @param chinese 中文字符串
     * @return 拼音字符串
     */
    private String convertToPinyin(String chinese)
    {
        if (StringUtils.isEmpty(chinese))
        {
            return "";
        }
        // 使用拼音工具类转换，如果没有则使用简单处理
        try
        {
            return PinyinUtil.getPinyin(chinese, "").toLowerCase();
        }
        catch (Exception e)
        {
            // 如果转换失败，使用英文字符和数字
            return chinese.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
        }
    }

    /**
     * 生成唯一的字段名
     * 
     * @param fieldLabel 字段标签（中文）
     * @param tableName 表名
     * @param existFields 现有字段列表
     * @return 唯一的字段名
     */
    private String generateUniqueFieldName(String fieldLabel, String tableName, List<TalentTemplateField> existFields)
    {
        // 基础字段名（拼音转换）
        String baseFieldName = convertToPinyin(fieldLabel);
        
        // 收集现有的所有字段名
        Set<String> existingFieldNames = new HashSet<>();
        for (TalentTemplateField field : existFields)
        {
            existingFieldNames.add(field.getFieldName());
        }
        
        // 如果基础名称不重复，直接使用
        if (!existingFieldNames.contains(baseFieldName))
        {
            // 再检查数据库表中是否存在该列
            try {
                if (!talentTemplateMapper.checkColumnExists(tableName, baseFieldName))
                {
                    return baseFieldName;
                }
            } catch (Exception e) {
                // 如果检查失败，继续下面的逻辑
                System.err.println("检查列是否存在失败: " + e.getMessage());
            }
        }
        
        // 如果重复，添加数字后缀
        int counter = 1;
        String uniqueFieldName;
        do {
            uniqueFieldName = baseFieldName + counter;
            counter++;
            
            // 检查是否超过合理范围，避免无限循环
            if (counter > 1000) {
                // 如果超过1000次尝试，使用时间戳确保唯一性
                uniqueFieldName = baseFieldName + System.currentTimeMillis();
                break;
            }
        } while (existingFieldNames.contains(uniqueFieldName) || 
                 (checkColumnExistsSafely(tableName, uniqueFieldName)));
        
        return uniqueFieldName;
    }
    
    /**
     * 安全检查列是否存在（避免异常中断流程）
     */
    private boolean checkColumnExistsSafely(String tableName, String fieldName)
    {
        try {
            return talentTemplateMapper.checkColumnExists(tableName, fieldName);
        } catch (Exception e) {
            // 如果检查失败，假设不存在（安全方向）
            System.err.println("检查列是否存在失败，假设不存在: " + e.getMessage());
            return false;
        }
    }

}

